package com.jason.www.jdk8;


import org.junit.Test;

import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Consumer;

/**
 * Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。可称为闭包
 * Lambda表达式基础语法,Java8中引入新的操作符"->"
 * Lambda表达式分为左右两部分:
 *  左:Lambda表达式的参数列表
 *  右:Lambda表达式中所需执行的功能,即Lambda体
 */
public class A_LambdaDemo {

    @Test
    public void test1(){
        Runnable r = new Runnable() {

            @Override
            public void run() {
                System.out.println("hello world");
            }
        };
        r.run();
        System.out.println("------------");

        //Lambda表达式
        Runnable runnable = () -> System.out.println("hello Lambda");
        runnable.run();
    }

    @Test
    public void test2(){
        Consumer<String> consumer = new Consumer<String>() {        //这里Consumer一个函数式接口，后面会讲到

            @Override
            public void accept(String t) {
                System.out.println(t);
            }
        };
        consumer.accept("hello consumer !");
        System.out.println("---------------");

        //Lambda表达式
        //      Consumer<String> con = (t) -> {System.out.println(t);}   如果形参只有一个，方法体只有一行，可以省略()和{}
        Consumer<String> con = t -> System.out.println(t);
        con.accept("hello Lambda !");
    }

    @Test
        public void test3(){
            Comparator<Integer> comparator = (x,y) -> {
                System.out.println("相加结果是:"+(x+y));
                return Integer.compare(x,y);
            };

            int compare = comparator.compare(1, 2);
            System.out.println(compare);
        }


    @Test
    public void test4(){
        Comparator<Integer> comparator = (x,y) -> Integer.compare(x,y);

        int compare = comparator.compare(1, 2);
        System.out.println(compare);
    }

    @Test
    public void test5(){
        show(new HashMap<>());
    }

    public void show(Map<String,Integer> map){

    }
}



/*
Lambda 表达式语法
语法格式一：无参，无返回值，Lambda 体只需一条语句
    Runnable runnable = () -> System.out.println("hello Lambda");
语法格式二：Lambda 需要一个参数
    Consumer<String> con = (t) -> System.out.println(t);
语法格式三：Lambda 只需要一个参数时，参数的小括号可以省略
    Consumer<String> con = t -> System.out.println(t);
语法格式四：Lambda 需要两个参数，并且有返回值
   Comparator<Integer> comparator = (x,y) -> {
        System.out.println("相加结果是:"+(x+y));
        return Integer.compare(x,y);
   };
语法格式五：当 Lambda 体只有一条语句时，return 与大括号可以省略
    Comparator<Integer> comparator = (x,y) -> Integer.compare(x,y);
语法格式六：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
    Comparator<Integer> comparator = (x,y) -> Integer.compare(x,y);
类型推断
上述 Lambda 表达式中的参数类型都是由编译器推断得出的。Lambda 表达式中无需指定类型，程序依然可以编译，
这是因为 javac 根据程序的上下文，在后台推断出了参数的类型。Lambda 表达式的类型依赖于上下文环境，
是由编译器推断出来的。这就是所谓的“类型推断”。
*/
